using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using NUnit.Framework;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.NUnitClassic
{
	
    public partial class MaskedEditExtenderTests
    {


        
        [Test]
        public void MaskedEditExtenderTests_Property_Mask_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.Mask = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Mask)) || expectedValue == objectUnderTest.Mask);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClipboardText_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClipboardText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClipboardText)) || expectedValue == objectUnderTest.ClipboardText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_MessageValidatorTip_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.MessageValidatorTip = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.MessageValidatorTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.MessageValidatorTip = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.MessageValidatorTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ErrorTooltipEnabled_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ErrorTooltipEnabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ErrorTooltipEnabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ErrorTooltipEnabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ErrorTooltipEnabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ErrorTooltipCssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ErrorTooltipCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorTooltipCssClass)) || expectedValue == objectUnderTest.ErrorTooltipCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClipboardEnabled_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ClipboardEnabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClipboardEnabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ClipboardEnabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClipboardEnabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_AutoComplete_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.AutoComplete = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AutoComplete);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.AutoComplete = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AutoComplete);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClearTextOnInvalid_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ClearTextOnInvalid = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClearTextOnInvalid);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ClearTextOnInvalid = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClearTextOnInvalid);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_AutoCompleteValue_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AutoCompleteValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AutoCompleteValue)) || expectedValue == objectUnderTest.AutoCompleteValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_Filtered_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.Filtered = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Filtered)) || expectedValue == objectUnderTest.Filtered);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_PromptCharacter_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.PromptCharacter = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.PromptCharacter)) || expectedValue == objectUnderTest.PromptCharacter);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_OnFocusCssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnFocusCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssClass)) || expectedValue == objectUnderTest.OnFocusCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_OnInvalidCssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnInvalidCssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnInvalidCssClass)) || expectedValue == objectUnderTest.OnInvalidCssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClearMaskOnLostFocus_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ClearMaskOnLostFocus = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClearMaskOnLostFocus);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ClearMaskOnLostFocus = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ClearMaskOnLostFocus);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureName_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureName = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureName)) || expectedValue == objectUnderTest.CultureName);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureDatePlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureDatePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDatePlaceholder)) || expectedValue == objectUnderTest.CultureDatePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureTimePlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureTimePlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureTimePlaceholder)) || expectedValue == objectUnderTest.CultureTimePlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureDecimalPlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureDecimalPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDecimalPlaceholder)) || expectedValue == objectUnderTest.CultureDecimalPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureThousandsPlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureThousandsPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureThousandsPlaceholder)) || expectedValue == objectUnderTest.CultureThousandsPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureDateFormat_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureDateFormat = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureDateFormat)) || expectedValue == objectUnderTest.CultureDateFormat);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureCurrencySymbolPlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureCurrencySymbolPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureCurrencySymbolPlaceholder)) || expectedValue == objectUnderTest.CultureCurrencySymbolPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_CultureAMPMPlaceholder_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CultureAMPMPlaceholder = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CultureAMPMPlaceholder)) || expectedValue == objectUnderTest.CultureAMPMPlaceholder);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_AcceptAMPM_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.AcceptAMPM = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AcceptAMPM);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.AcceptAMPM = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.AcceptAMPM);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_OnFocusCssNegative_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnFocusCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnFocusCssNegative)) || expectedValue == objectUnderTest.OnFocusCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_OnBlurCssNegative_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.OnBlurCssNegative = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.OnBlurCssNegative)) || expectedValue == objectUnderTest.OnBlurCssNegative);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_Century_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int32 expectedValue;
        
            
            try
            {
                expectedValue = Int32.MinValue;
                objectUnderTest.Century = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Century);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)(-1);
                objectUnderTest.Century = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Century);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)0;
                objectUnderTest.Century = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Century);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int32)1;
                objectUnderTest.Century = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Century);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int32.MaxValue;
                objectUnderTest.Century = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Century);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_SkinID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_Enabled_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ScriptPath_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ScriptPath = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ScriptPath)) || expectedValue == objectUnderTest.ScriptPath);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_BehaviorID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.BehaviorID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BehaviorID)) || expectedValue == objectUnderTest.BehaviorID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClientState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientState = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientState)) || expectedValue == objectUnderTest.ClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ClientStateFieldID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientStateFieldID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientStateFieldID)) || expectedValue == objectUnderTest.ClientStateFieldID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_EnableClientState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableClientState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableClientState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_TargetControlID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.TargetControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TargetControlID)) || expectedValue == objectUnderTest.TargetControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_Visible_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_ID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_EnableTheming_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_EnableViewState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [Test]
        public void MaskedEditExtenderTests_Property_AppRelativeTemplateSourceDirectory_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
    }
}

